#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <ctype.h>
#include <fcntl.h>
using namespace std;

const int basesize = 1024;
const int argvnum = 64;
const int envnum = 64;

//  全局的命令行参数表
char *gargv[argvnum];
int gargc = 0;

// 全局变量 -- 保存命令退出时的退出结果
int lastcode = 0;

// 我的系统环境变量表
char *genv[envnum]; //自己维护当前表

// 全局的当前 shell 工作路径
char pwd[basesize];
char pwdenv[basesize];


// 全局遍历 与 重定向有关
#define NoneRedir 0
#define InputRedir 1
#define OutputRedir 2
#define AppRedir 3

int redir = NoneRedir;
char *filename = nullptr;

// " "file.txt 从左向右扫描不是空格的字符
// do while(0) 套壳
#define TrimSpace(pos) do{\
    while(isspace(*pos)){\
        pos++;\
    }\
}while(0)


string GetUserName() // 获取用户名
{
    string name = getenv("USER");
    //return name;
    // 为防止获取失败 
    return name.empty() ? "None" : name;
}

string GetHostName() // 获取主机名
{
    string hostname = getenv("HOSTNAME");
    return hostname.empty() ? "None" : hostname;
}

string GetPwd() // 获取当前工作路径
{
    // 从 shell 系统中获取当前路径
    if(nullptr == getcwd(pwd, sizeof(pwd))) return "None";
    // 当前环境变量中工作路径的更新
    snprintf(pwdenv, sizeof(pwdenv), "PWD=%s", pwd);
    putenv(pwdenv); // PWD =xxx

    // 修改当前维护的环境变量表
    for(int i = 0; genv[i]; i++)
    {
        string s = genv[i]; //获取当前字符串
        if(s[0] == 'P' && s[1] == 'W' && s[2] == 'D')
        {
            genv[i] = pwdenv; 
            break;
        }
    }

    return pwd;
    
    //string pwd = getenv("PWD");
    //return pwd.empty() ? "None" : pwd;
}

string LastDir()
{
    string curr = GetPwd();
    if(curr == "/" || curr == "None") return curr;
    // /home/lighthouse/最近路径名
    size_t pos = curr.rfind("/"); // 从最后面开始找

    if(pos == std::string::npos) return curr; // 未找到的情况

    return curr.substr(pos + 1);
}


string MakeCommandLine() //生成命令行提示符
{
    // [lighthouse@VM-8-10-centos myshell] $
    char command_line[basesize]; // 定义数组，使用接口 
    // snprintf 安全地把我们的参数按照指定格式写入到缓冲区字符串里
    snprintf(command_line, basesize, "[%s@%s %s]# ", \
            GetUserName().c_str(), GetHostName().c_str(), LastDir().c_str());
    return command_line;
}


void PrintCommandLine() // 1. 命令行提示符
{
    printf("%s", MakeCommandLine().c_str()); // 没有 \n
    fflush(stdout); //让 printf 打印的字符串立马刷新出来
}

// 把键盘获取的字符串放到当前缓冲区里
bool GetCommandLine(char command_buffer[], int size)
{
    // 认为：我们要将用户输入命令行，当做一个完整字符串
    // "ls -a -l -n"
    char *result = fgets(command_buffer, size, stdin); // 从标准输入中获取
    if(!result)
    {
        return false;
    }
    command_buffer[strlen(command_buffer)-1] = 0; // 去掉最后的 '\n'
    return true;
}

void ResetCommandLine()
{
    // 虽然定义的是全局默认为0，但是由于这些工作都是重复去做的，为保证安全性，需要局部初始为0
    memset(gargv, 0, sizeof(gargv));
    gargc = 0;

    // 重定向
    redir = NoneRedir;
    filename = nullptr;
}

void ParseRedir(char command_buffer[], int len) // 解析重定向
{
    //printf("command start: %s\n", command_buffer); //  -- 测试

    // "ls -a -b -c -d " > hello.txt
    // "ls -a -b -c -d " >> hello.txt
    // "ls -a -b -c -d " < hello.txt
    int end = len - 1;
    while(end >= 0)
    {
        if(command_buffer[end] == '<') // 输入重定向
        {
            redir = InputRedir;
            // 拿到干净的文件名
            command_buffer[end] = 0;
            filename = &command_buffer[end] + 1;
            TrimSpace(filename); // 跳过空格部分   
            break;
        }
        else if(command_buffer[end] == '>')
        {
            if(command_buffer[end - 1] == '>') // 追加重定向
            {
                redir = AppRedir;
                command_buffer[end] = 0;
                command_buffer[end - 1] = 0;
                filename = &command_buffer[end] + 1;
                TrimSpace(filename);
                break;
            }
            else // 输出重定向
            {
                redir = OutputRedir;
                command_buffer[end] = 0;
                filename = &command_buffer[end] + 1;
                TrimSpace(filename);
                break;
            }
        }
        else
        {
            end--;
        }
    }
}

void ParseCommand(char command_buffer[])
{
        // 拆分读取的字符串
    // "ls -a -l -n"
    const char *sep = " "; //分隔符

// // 方式一：
//     //strtok(command_buffer, sep); // 切的字符串，分隔符
//     gargv[gargc++] = strtok(command_buffer, sep); // gargv 保存的是 ls 
    
//     // 传 nullptr，表示切历史上一次字符串，如果传command_buffer，就会重新开始切了
//     // = 是刻意写的
//     // bool 强转避免告警
//     while((bool)(gargv[gargc++] = strtok(nullptr, sep))); // 形成上面图片的结构
//     gargc--; // 避免等于 NUll 时多加 一次


// 方式二；
    for(char* ch = strtok(command_buffer, sep); (bool) ch; ch = strtok(nullptr, sep)) 
    {
        gargv[gargc++] = ch;
    }
}

void ParseCommandLine(char command_buffer[], int len) // 3. 分析命令
{
    // 给其分成 3 部分
    // 1. 初始化
    (void)len; // 避免不使用的时候告警
    ResetCommandLine();

    // 2. 解析重定向
    ParseRedir(command_buffer, len);

    // 3. 解析命令
    ParseCommand(command_buffer);
}



void debug()
{
    printf("argc: %d\n",gargc); // 打印当前的命令行字符串数目 
    for(int i = 0; gargv[i]; i++)
    {
        printf("argv[%d]: %s\n", i, gargv[i]); //打印当前所有命令行
    }
}


void DoRedir()
{
    // 1. 重定向应该让子进程自己做
    // 2. 程序替换会不会影响重定向
    // 0. 先判断 && 重定向
    if(redir == InputRedir) // 输入重定向
    {
        if(filename)
        {
            int fd = open(filename, O_RDONLY);
            if(fd < 0) // 子进程打开失败
            {
                exit(2);
            }
            dup2(fd, 0);
        }
        else
        {
            exit(1);
        }
    }
    else if(redir == OutputRedir) // 输出重定向
    {
        if(filename)
        {
            int fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0666);
            if(fd < 0) // 子进程打开失败
            {
                exit(4);
            }
            dup2(fd, 1);
        }
        else
        {
            exit(3);
        }
    }
    else if(redir == AppRedir) // 追加重定向
    {
        if(filename)
        {
            int fd = open(filename, O_CREAT | O_WRONLY | O_APPEND, 0666);
            if(fd < 0) // 子进程打开失败
            {
                exit(6);
            }
            dup2(fd, 1);
        }
        else
        {
            exit(5);
        }
    }
    else
    {   
        // 没有重定向，Do Nothing
    }
}


// 在 shell 中
// 有些命令，必须由子进程来执行
// 有些命令，不能由子进程来执行，由shell 自己执行 --- 内建命令
bool ExecuteCommand() // 4. 执行命令
{
    // 让子进程进行执行
    pid_t id = fork();
    if(id < 0) return false;
    if(id == 0)
    {       
        // 子进程
        DoRedir(); 
        // 1. 执行命令
        //execvp(gargv[0], gargv);
        execvpe(gargv[0], gargv, genv); // 把我们的环境变量传递给子进程了

        // 2. 退出
        exit(1); // 要进行程序替换，只有子进程失败，才会 exit。

    }

    int status = 0;
    pid_t rid = waitpid(id, &status, 0); // 阻塞等待
    if(rid > 0)
    {
        if(WIFEXITED(status)) // 等待成功获取退出信息
        {
            lastcode = WEXITSTATUS(status);
        }
        else
        {
            lastcode = 100; //非正常退出
        }
        return true;
    }
    return false;
}


// 添加环境变量
void AddEnv(const char *item)
{
    int index = 0;
    while(genv[index])
    {
        index++;
    }

    genv[index] = (char*) malloc(strlen(item)+1); // 重新申请空间
    strncpy(genv[index], item, strlen(item)+1); // 拷贝复制
    genv[++index] = nullptr; // 最后为空
}


// shell 自己执行命令, 本质：shell 调用自己的函数
bool CheckAndExecBuiltCommand()
{
    //检测其是否为内建命令 -- 穷举法
    if(strcmp(gargv[0], "cd") == 0) 
    {
        // 内建命令
        if(gargc == 2) 
        {
            chdir(gargv[1]); // 可以用 chdir，自己调用自己的函数直接改变 shell 工作路径
            lastcode = 0;
        }
        else
        {
            lastcode = 1;
        }
        return true;
    }
    else if(strcmp(gargv[0], "export") == 0)
    {
        // export 也是内建命令
        if(gargc == 2)
        {
            AddEnv(gargv[1]); //添加到环境变量表里面
            lastcode = 0;
        }
        else
        {
            lastcode = 2;
        }
        return true;
    }   

    else if(strcmp(gargv[0], "env") == 0)
    {
        for(int i = 0; genv[i]; i++)
        {
            printf("%s\n", genv[i]);
        }
        lastcode = 0;
        return true;
    }

    else if(strcmp(gargv[0], "echo") == 0)
    {
        if(gargc == 2)
        {
            // echo $?
            // echo $PATH
            // echo hello
            if(gargv[1][0] == '$')
            {
                if(gargv[1][1] == '?')
                {
                    printf("%d\n",lastcode);
                    lastcode = 0; // 查一次清0
                }
            }
            else
            {
                printf("%s\n", gargv[1]);
            }
        }
        else
        {
            lastcode = 3;
        }
        return true;
    }

    return false;
}

// 作为一个 shell 获取环境变量应该从系统配置文件 来
// 今天就直接从 父 shell 获取环境变量
// 本质：把系统的环境变量拷贝到 shell 当中
void InitEnv()
{
    extern char **environ; //获取环境变量
    int index = 0;
    while(environ[index])
    {
        genv[index] = (char*)malloc(strlen(environ[index]) + 1); //malloc 出自己维护的空间
        // 拷贝复制
        strncpy(genv[index], environ[index], strlen(environ[index]) + 1);
        index++;
    }
    genv[index] = nullptr;
}


int main()
{
    InitEnv(); // 初始化环境变量表
    char command_buffer[basesize];
    while(true) // 不断重复该工作
    {
        // 下面三步可以不断生成命令行提示符
        PrintCommandLine(); // 1. 命令行提示符
        //printf("\n");
        //sleep(1); 

        // command_buffer -> output(输出型参数)，把 ls -a -l 看作一个字符串
        if(!GetCommandLine(command_buffer, basesize))   // 2. 获取用户命令
        {
            continue;
        }
        //printf("%s\n", command_buffer); //测试

        // ls -a -b -c 解析每个指令 > "ls" "-a" "-b" "-c" 拆成一个一个字符串
        // 重定向格式
        // "ls -a -b -c -d " -> "ls" "-a" "-b"
        // "ls -a -b -c -d " >> hello.txt
        // "ls -a -b -c -d " < hello.txt
        ParseCommandLine(command_buffer, strlen(command_buffer)); // 3. 分析命令

        //debug();
        
        // 检测
        // printf("redir: %d\n", redir);
        // printf("filename: %s\n", filename);
        // printf("command end: %s\n", command_buffer);

        if(CheckAndExecBuiltCommand())
        {
            continue;
        }

        ExecuteCommand(); // 4. 执行命令
    }
    return 0;
}









